1 /*
2 _ _ _ _
3 ___| (_) ___| | __ (_)___
4 / __| | |/ __| |/ / | / __|
5 \__ \ | | (__| < _ | \__ \
6 |___/_|_|\___|_|\_(_)/ |___/
7 |__/
8
9 Version: 1.8.0
10 Author: Ken Wheeler
11 Website: http://kenwheeler.github.io
12 Docs: http://kenwheeler.github.io/slick
13 Repo: http://github.com/kenwheeler/slick
14 Issues: http://github.com/kenwheeler/slick/issues
15
16 */
17 /* global window, document, define, jQuery, setInterval, clearInterval */
18 ;(function(factory) {
19 'use strict';
20 if (typeof define === 'function' && define.amd) {
21 define(['jquery'], factory);
22 } else if (typeof exports !== 'undefined') {
23 module.exports = factory(require('jquery'));
24 } else {
25 factory(jQuery);
26 }
27
28 }(function($) {
29 'use strict';
30 var Slick = window.Slick || {};
31
32 Slick = (function() {
33
34 var instanceUid = 0;
35
36 function Slick(element, settings) {
37
38 var _ = this, dataSettings;
39
40 _.defaults = {
41 accessibility: true,
42 adaptiveHeight: false,
43 appendArrows: $(element),
44 appendDots: $(element),
45 arrows: true,
46 asNavFor: null,
47 prevArrow: '<button class="slick-prev" aria-label="Previous" type="button">Previous</button>',
48 nextArrow: '<button class="slick-next" aria-label="Next" type="button">Next</button>',
49 autoplay: false,
50 autoplaySpeed: 3000,
51 centerMode: false,
52 centerPadding: '50px',
53 cssEase: 'ease',
54 customPaging: function(slider, i) {
55 return $('<button type="button" />').text(i + 1);
56 },
57 dots: false,
58 dotsClass: 'slick-dots',
59 draggable: true,
60 easing: 'linear',
61 edgeFriction: 0.35,
62 fade: false,
63 focusOnSelect: false,
64 focusOnChange: false,
65 infinite: true,
66 initialSlide: 0,
67 lazyLoad: 'ondemand',
68 mobileFirst: false,
69 pauseOnHover: true,
70 pauseOnFocus: true,
71 pauseOnDotsHover: false,
72 respondTo: 'window',
73 responsive: null,
74 rows: 1,
75 rtl: false,
76 slide: '',
77 slidesPerRow: 1,
78 slidesToShow: 1,
79 slidesToScroll: 1,
80 speed: 500,
81 swipe: true,
82 swipeToSlide: false,
83 touchMove: true,
84 touchThreshold: 5,
85 useCSS: true,
86 useTransform: true,
87 variableWidth: false,
88 vertical: false,
89 verticalSwiping: false,
90 waitForAnimate: true,
91 zIndex: 1000
92 };
93
94 _.initials = {
95 animating: false,
96 dragging: false,
97 autoPlayTimer: null,
98 currentDirection: 0,
99 currentLeft: null,
100 currentSlide: 0,
101 direction: 1,
102 $dots: null,
103 listWidth: null,
104 listHeight: null,
105 loadIndex: 0,
106 $nextArrow: null,
107 $prevArrow: null,
108 scrolling: false,
109 slideCount: null,
110 slideWidth: null,
111 $slideTrack: null,
112 $slides: null,
113 sliding: false,
114 slideOffset: 0,
115 swipeLeft: null,
116 swiping: false,
117 $list: null,
118 touchObject: {},
119 transformsEnabled: false,
120 unslicked: false
121 };
122
123 $.extend(_, _.initials);
124
125 _.activeBreakpoint = null;
126 _.animType = null;
127 _.animProp = null;
128 _.breakpoints = [];
129 _.breakpointSettings = [];
130 _.cssTransitions = false;
131 _.focussed = false;
132 _.interrupted = false;
133 _.hidden = 'hidden';
134 _.paused = true;
135 _.positionProp = null;
136 _.respondTo = null;
137 _.rowCount = 1;
138 _.shouldClick = true;
139 _.$slider = $(element);
140 _.$slidesCache = null;
141 _.transformType = null;
142 _.transitionType = null;
143 _.visibilityChange = 'visibilitychange';
144 _.windowWidth = 0;
145 _.windowTimer = null;
146
147 dataSettings = $(element).data('slick') || {};
148
149 _.options = $.extend({}, _.defaults, settings, dataSettings);
150
151 _.currentSlide = _.options.initialSlide;
152
153 _.originalSettings = _.options;
154
155 if (typeof document.mozHidden !== 'undefined') {
156 _.hidden = 'mozHidden';
157 _.visibilityChange = 'mozvisibilitychange';
158 } else if (typeof document.webkitHidden !== 'undefined') {
159 _.hidden = 'webkitHidden';
160 _.visibilityChange = 'webkitvisibilitychange';
161 }
162
163 _.autoPlay = $.proxy(_.autoPlay, _);
164 _.autoPlayClear = $.proxy(_.autoPlayClear, _);
165 _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
166 _.changeSlide = $.proxy(_.changeSlide, _);
167 _.clickHandler = $.proxy(_.clickHandler, _);
168 _.selectHandler = $.proxy(_.selectHandler, _);
169 _.setPosition = $.proxy(_.setPosition, _);
170 _.swipeHandler = $.proxy(_.swipeHandler, _);
171 _.dragHandler = $.proxy(_.dragHandler, _);
172 _.keyHandler = $.proxy(_.keyHandler, _);
173
174 _.instanceUid = instanceUid++;
175
176 // A simple way to check for HTML strings
177 // Strict HTML recognition (must start with <)
178 // Extracted from jQuery v1.11 source
179 _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
180
181
182 _.registerBreakpoints();
183 _.init(true);
184
185 }
186
187 return Slick;
188
189 }());
190
191 Slick.prototype.activateADA = function() {
192 var _ = this;
193
194 _.$slideTrack.find('.slick-active').attr({
195 'aria-hidden': 'false'
196 }).find('a, input, button, select').attr({
197 'tabindex': '0'
198 });
199
200 };
201
202 Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {
203
204 var _ = this;
205
206 if (typeof(index) === 'boolean') {
207 addBefore = index;
208 index = null;
209 } else if (index < 0 || (index >= _.slideCount)) {
210 return false;
211 }
212
213 _.unload();
214
215 if (typeof(index) === 'number') {
216 if (index === 0 && _.$slides.length === 0) {
217 $(markup).appendTo(_.$slideTrack);
218 } else if (addBefore) {
219 $(markup).insertBefore(_.$slides.eq(index));
220 } else {
221 $(markup).insertAfter(_.$slides.eq(index));
222 }
223 } else {
224 if (addBefore === true) {
225 $(markup).prependTo(_.$slideTrack);
226 } else {
227 $(markup).appendTo(_.$slideTrack);
228 }
229 }
230
231 _.$slides = _.$slideTrack.children(this.options.slide);
232
233 _.$slideTrack.children(this.options.slide).detach();
234
235 _.$slideTrack.append(_.$slides);
236
237 _.$slides.each(function(index, element) {
238 $(element).attr('data-slick-index', index);
239 });
240
241 _.$slidesCache = _.$slides;
242
243 _.reinit();
244
245 };
246
247 Slick.prototype.animateHeight = function() {
248 var _ = this;
249 if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
250 var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
251 _.$list.animate({
252 height: targetHeight
253 }, _.options.speed);
254 }
255 };
256
257 Slick.prototype.animateSlide = function(targetLeft, callback) {
258
259 var animProps = {},
260 _ = this;
261
262 _.animateHeight();
263
264 if (_.options.rtl === true && _.options.vertical === false) {
265 targetLeft = -targetLeft;
266 }
267 if (_.transformsEnabled === false) {
268 if (_.options.vertical === false) {
269 _.$slideTrack.animate({
270 left: targetLeft
271 }, _.options.speed, _.options.easing, callback);
272 } else {
273 _.$slideTrack.animate({
274 top: targetLeft
275 }, _.options.speed, _.options.easing, callback);
276 }
277
278 } else {
279
280 if (_.cssTransitions === false) {
281 if (_.options.rtl === true) {
282 _.currentLeft = -(_.currentLeft);
283 }
284 $({
285 animStart: _.currentLeft
286 }).animate({
287 animStart: targetLeft
288 }, {
289 duration: _.options.speed,
290 easing: _.options.easing,
291 step: function(now) {
292 now = Math.ceil(now);
293 if (_.options.vertical === false) {
294 animProps[_.animType] = 'translate(' +
295 now + 'px, 0px)';
296 _.$slideTrack.css(animProps);
297 } else {
298 animProps[_.animType] = 'translate(0px,' +
299 now + 'px)';
300 _.$slideTrack.css(animProps);
301 }
302 },
303 complete: function() {
304 if (callback) {
305 callback.call();
306 }
307 }
308 });
309
310 } else {
311
312 _.applyTransition();
313 targetLeft = Math.ceil(targetLeft);
314
315 if (_.options.vertical === false) {
316 animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
317 } else {
318 animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
319 }
320 _.$slideTrack.css(animProps);
321
322 if (callback) {
323 setTimeout(function() {
324
325 _.disableTransition();
326
327 callback.call();
328 }, _.options.speed);
329 }
330
331 }
332
333 }
334
335 };
336
337 Slick.prototype.getNavTarget = function() {
338
339 var _ = this,
340 asNavFor = _.options.asNavFor;
341
342 if ( asNavFor && asNavFor !== null ) {
343 asNavFor = $(asNavFor).not(_.$slider);
344 }
345
346 return asNavFor;
347
348 };
349
350 Slick.prototype.asNavFor = function(index) {
351
352 var _ = this,
353 asNavFor = _.getNavTarget();
354
355 if ( asNavFor !== null && typeof asNavFor === 'object' ) {
356 asNavFor.each(function() {
357 var target = $(this).slick('getSlick');
358 if(!target.unslicked) {
359 target.slideHandler(index, true);
360 }
361 });
362 }
363
364 };
365
366 Slick.prototype.applyTransition = function(slide) {
367
368 var _ = this,
369 transition = {};
370
371 if (_.options.fade === false) {
372 transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
373 } else {
374 transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
375 }
376
377 if (_.options.fade === false) {
378 _.$slideTrack.css(transition);
379 } else {
380 _.$slides.eq(slide).css(transition);
381 }
382
383 };
384
385 Slick.prototype.autoPlay = function() {
386
387 var _ = this;
388
389 _.autoPlayClear();
390
391 if ( _.slideCount > _.options.slidesToShow ) {
392 _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );
393 }
394
395 };
396
397 Slick.prototype.autoPlayClear = function() {
398
399 var _ = this;
400
401 if (_.autoPlayTimer) {
402 clearInterval(_.autoPlayTimer);
403 }
404
405 };
406
407 Slick.prototype.autoPlayIterator = function() {
408
409 var _ = this,
410 slideTo = _.currentSlide + _.options.slidesToScroll;
411
412 if ( !_.paused && !_.interrupted && !_.focussed ) {
413
414 if ( _.options.infinite === false ) {
415
416 if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {
417 _.direction = 0;
418 }
419
420 else if ( _.direction === 0 ) {
421
422 slideTo = _.currentSlide - _.options.slidesToScroll;
423
424 if ( _.currentSlide - 1 === 0 ) {
425 _.direction = 1;
426 }
427
428 }
429
430 }
431
432 _.slideHandler( slideTo );
433
434 }
435
436 };
437
438 Slick.prototype.buildArrows = function() {
439
440 var _ = this;
441
442 if (_.options.arrows === true ) {
443
444 _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
445 _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');
446
447 if( _.slideCount > _.options.slidesToShow ) {
448
449 _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
450 _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
451
452 if (_.htmlExpr.test(_.options.prevArrow)) {
453 _.$prevArrow.prependTo(_.options.appendArrows);
454 }
455
456 if (_.htmlExpr.test(_.options.nextArrow)) {
457 _.$nextArrow.appendTo(_.options.appendArrows);
458 }
459
460 if (_.options.infinite !== true) {
461 _.$prevArrow
462 .addClass('slick-disabled')
463 .attr('aria-disabled', 'true');
464 }
465
466 } else {
467
468 _.$prevArrow.add( _.$nextArrow )
469
470 .addClass('slick-hidden')
471 .attr({
472 'aria-disabled': 'true',
473 'tabindex': '-1'
474 });
475
476 }
477
478 }
479
480 };
481
482 Slick.prototype.buildDots = function() {
483
484 var _ = this,
485 i, dot;
486
487 if (_.options.dots === true) {
488
489 _.$slider.addClass('slick-dotted');
490
491 dot = $('<ul />').addClass(_.options.dotsClass);
492
493 for (i = 0; i <= _.getDotCount(); i += 1) {
494 dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
495 }
496
497 _.$dots = dot.appendTo(_.options.appendDots);
498
499 _.$dots.find('li').first().addClass('slick-active');
500
501 }
502
503 };
504
505 Slick.prototype.buildOut = function() {
506
507 var _ = this;
508
509 _.$slides =
510 _.$slider
511 .children( _.options.slide + ':not(.slick-cloned)')
512 .addClass('slick-slide');
513
514 _.slideCount = _.$slides.length;
515
516 _.$slides.each(function(index, element) {
517 $(element)
518 .attr('data-slick-index', index)
519 .data('originalStyling', $(element).attr('style') || '');
520 });
521
522 _.$slider.addClass('slick-slider');
523
524 _.$slideTrack = (_.slideCount === 0) ?
525 $('<div class="slick-track"/>').appendTo(_.$slider) :
526 _.$slides.wrapAll('<div class="slick-track"/>').parent();
527
528 _.$list = _.$slideTrack.wrap(
529 '<div class="slick-list"/>').parent();
530 _.$slideTrack.css('opacity', 0);
531
532 if (_.options.centerMode === true || _.options.swipeToSlide === true) {
533 _.options.slidesToScroll = 1;
534 }
535
536 $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
537
538 _.setupInfinite();
539
540 _.buildArrows();
541
542 _.buildDots();
543
544 _.updateDots();
545
546
547 _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
548
549 if (_.options.draggable === true) {
550 _.$list.addClass('draggable');
551 }
552
553 };
554
555 Slick.prototype.buildRows = function() {
556
557 var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;
558
559 newSlides = document.createDocumentFragment();
560 originalSlides = _.$slider.children();
561
562 if(_.options.rows > 1) {
563
564 slidesPerSection = _.options.slidesPerRow * _.options.rows;
565 numOfSlides = Math.ceil(
566 originalSlides.length / slidesPerSection
567 );
568
569 for(a = 0; a < numOfSlides; a++){
570 var slide = document.createElement('div');
571 for(b = 0; b < _.options.rows; b++) {
572 var row = document.createElement('div');
573 for(c = 0; c < _.options.slidesPerRow; c++) {
574 var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));
575 if (originalSlides.get(target)) {
576 row.appendChild(originalSlides.get(target));
577 }
578 }
579 slide.appendChild(row);
580 }
581 newSlides.appendChild(slide);
582 }
583
584 _.$slider.empty().append(newSlides);
585 _.$slider.children().children().children()
586 .css({
587 'width':(100 / _.options.slidesPerRow) + '%',
588 'display': 'inline-block'
589 });
590
591 }
592
593 };
594
595 Slick.prototype.checkResponsive = function(initial, forceUpdate) {
596
597 var _ = this,
598 breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;
599 var sliderWidth = _.$slider.width();
600 var windowWidth = window.innerWidth || $(window).width();
601
602 if (_.respondTo === 'window') {
603 respondToWidth = windowWidth;
604 } else if (_.respondTo === 'slider') {
605 respondToWidth = sliderWidth;
606 } else if (_.respondTo === 'min') {
607 respondToWidth = Math.min(windowWidth, sliderWidth);
608 }
609
610 if ( _.options.responsive &&
611 _.options.responsive.length &&
612 _.options.responsive !== null) {
613
614 targetBreakpoint = null;
615
616 for (breakpoint in _.breakpoints) {
617 if (_.breakpoints.hasOwnProperty(breakpoint)) {
618 if (_.originalSettings.mobileFirst === false) {
619 if (respondToWidth < _.breakpoints[breakpoint]) {
620 targetBreakpoint = _.breakpoints[breakpoint];
621 }
622 } else {
623 if (respondToWidth > _.breakpoints[breakpoint]) {
624 targetBreakpoint = _.breakpoints[breakpoint];
625 }
626 }
627 }
628 }
629
630 if (targetBreakpoint !== null) {
631 if (_.activeBreakpoint !== null) {
632 if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
633 _.activeBreakpoint =
634 targetBreakpoint;
635 if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
636 _.unslick(targetBreakpoint);
637 } else {
638 _.options = $.extend({}, _.originalSettings,
639 _.breakpointSettings[
640 targetBreakpoint]);
641 if (initial === true) {
642 _.currentSlide = _.options.initialSlide;
643 }
644 _.refresh(initial);
645 }
646 triggerBreakpoint = targetBreakpoint;
647 }
648 } else {
649 _.activeBreakpoint = targetBreakpoint;
650 if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
651 _.unslick(targetBreakpoint);
652 } else {
653 _.options = $.extend({}, _.originalSettings,
654 _.breakpointSettings[
655 targetBreakpoint]);
656 if (initial === true) {
657 _.currentSlide = _.options.initialSlide;
658 }
659 _.refresh(initial);
660 }
661 triggerBreakpoint = targetBreakpoint;
662 }
663 } else {
664 if (_.activeBreakpoint !== null) {
665 _.activeBreakpoint = null;
666 _.options = _.originalSettings;
667 if (initial === true) {
668 _.currentSlide = _.options.initialSlide;
669 }
670 _.refresh(initial);
671 triggerBreakpoint = targetBreakpoint;
672 }
673 }
674
675 // only trigger breakpoints during an actual break. not on initialize.
676 if( !initial && triggerBreakpoint !== false ) {
677 _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
678 }
679 }
680
681 };
682
683 Slick.prototype.changeSlide = function(event, dontAnimate) {
684
685 var _ = this,
686 $target = $(event.currentTarget),
687 indexOffset, slideOffset, unevenOffset;
688
689 // If target is a link, prevent default action.
690 if($target.is('a')) {
691 event.preventDefault();
692 }
693
694 // If target is not the <li> element (ie: a child), find the <li>.
695 if(!$target.is('li')) {
696 $target = $target.closest('li');
697 }
698
699 unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
700 indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
701
702 switch (event.data.message) {
703
704 case 'previous':
705 slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
706 if (_.slideCount > _.options.slidesToShow) {
707 _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
708 }
709 break;
710
711 case 'next':
712 slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
713 if (_.slideCount > _.options.slidesToShow) {
714 _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
715 }
716 break;
717
718 case 'index':
719 var index = event.data.index === 0 ? 0 :
720 event.data.index || $target.index() * _.options.slidesToScroll;
721
722 _.slideHandler(_.checkNavigable(index), false, dontAnimate);
723 $target.children().trigger('focus');
724 break;
725
726 default:
727 return;
728 }
729
730 };
731
732 Slick.prototype.checkNavigable = function(index) {
733
734 var _ = this,
735 navigables, prevNavigable;
736
737 navigables = _.getNavigableIndexes();
738 prevNavigable = 0;
739 if (index > navigables[navigables.length - 1]) {
740 index = navigables[navigables.length - 1];
741 } else {
742 for (var n in navigables) {
743 if (index < navigables[n]) {
744 index = prevNavigable;
745 break;
746 }
747 prevNavigable = navigables[n];
748 }
749 }
750
751 return index;
752 };
753
754 Slick.prototype.cleanUpEvents = function() {
755
756 var _ = this;
757
758 if (_.options.dots && _.$dots !== null) {
759
760 $('li', _.$dots)
761 .off('click.slick', _.changeSlide)
762 .off('mouseenter.slick', $.proxy(_.interrupt, _, true))
763 .off('mouseleave.slick', $.proxy(_.interrupt, _, false));
764
765 if (_.options.accessibility === true) {
766 _.$dots.off('keydown.slick', _.keyHandler);
767 }
768 }
769
770 _.$slider.off('focus.slick blur.slick');
771
772 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
773 _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
774 _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
775
776 if (_.options.accessibility === true) {
777 _.$prevArrow && _.$prevArrow.off('keydown.slick', _.keyHandler);
778 _.$nextArrow && _.$nextArrow.off('keydown.slick', _.keyHandler);
779 }
780 }
781
782 _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
783 _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
784 _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
785 _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);
786
787 _.$list.off('click.slick', _.clickHandler);
788
789 $(document).off(_.visibilityChange, _.visibility);
790
791 _.cleanUpSlideEvents();
792
793 if (_.options.accessibility === true) {
794 _.$list.off('keydown.slick', _.keyHandler);
795 }
796
797 if (_.options.focusOnSelect === true) {
798 $(_.$slideTrack).children().off('click.slick', _.selectHandler);
799 }
800
801 $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);
802
803 $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);
804
805 $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);
806
807 $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
808
809 };
810
811 Slick.prototype.cleanUpSlideEvents = function() {
812
813 var _ = this;
814
815 _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
816 _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));
817
818 };
819
820 Slick.prototype.cleanUpRows = function() {
821
822 var _ = this, originalSlides;
823
824 if(_.options.rows > 1) {
825 originalSlides = _.$slides.children().children();
826 originalSlides.removeAttr('style');
827 _.$slider.empty().append(originalSlides);
828 }
829
830 };
831
832 Slick.prototype.clickHandler = function(event) {
833
834 var _ = this;
835
836 if (_.shouldClick === false) {
837 event.stopImmediatePropagation();
838 event.stopPropagation();
839 event.preventDefault();
840 }
841
842 };
843
844 Slick.prototype.destroy = function(refresh) {
845
846 var _ = this;
847
848 _.autoPlayClear();
849
850 _.touchObject = {};
851
852 _.cleanUpEvents();
853
854 $('.slick-cloned', _.$slider).detach();
855
856 if (_.$dots) {
857 _.$dots.remove();
858 }
859
860 if ( _.$prevArrow && _.$prevArrow.length ) {
861
862 _.$prevArrow
863 .removeClass('slick-disabled slick-arrow slick-hidden')
864 .removeAttr('aria-hidden aria-disabled tabindex')
865 .css('display','');
866
867 if ( _.htmlExpr.test( _.options.prevArrow )) {
868 _.$prevArrow.remove();
869 }
870 }
871
872 if ( _.$nextArrow && _.$nextArrow.length ) {
873
874 _.$nextArrow
875 .removeClass('slick-disabled slick-arrow slick-hidden')
876 .removeAttr('aria-hidden aria-disabled tabindex')
877 .css('display','');
878
879 if ( _.htmlExpr.test( _.options.nextArrow )) {
880 _.$nextArrow.remove();
881 }
882 }
883
884
885 if (_.$slides) {
886
887 _.$slides
888 .removeClass('slick-slide slick-active slick-center slick-visible slick-current')
889 .removeAttr('aria-hidden')
890 .removeAttr('data-slick-index')
891 .each(function(){
892 $(this).attr('style', $(this).data('originalStyling'));
893 });
894
895 _.$slideTrack.children(this.options.slide).detach();
896
897 _.$slideTrack.detach();
898
899 _.$list.detach();
900
901 _.$slider.append(_.$slides);
902 }
903
904 _.cleanUpRows();
905
906 _.$slider.removeClass('slick-slider');
907 _.$slider.removeClass('slick-initialized');
908 _.$slider.removeClass('slick-dotted');
909
910 _.unslicked = true;
911
912 if(!refresh) {
913 _.$slider.trigger('destroy', [_]);
914 }
915
916 };
917
918 Slick.prototype.disableTransition = function(slide) {
919
920 var _ = this,
921 transition = {};
922
923 transition[_.transitionType] = '';
924
925 if (_.options.fade === false) {
926 _.$slideTrack.css(transition);
927 } else {
928 _.$slides.eq(slide).css(transition);
929 }
930
931 };
932
933 Slick.prototype.fadeSlide = function(slideIndex, callback) {
934
935 var _ = this;
936
937 if (_.cssTransitions === false) {
938
939 _.$slides.eq(slideIndex).css({
940 zIndex: _.options.zIndex
941 });
942
943 _.$slides.eq(slideIndex).animate({
944 opacity: 1
945 }, _.options.speed, _.options.easing, callback);
946
947 } else {
948
949 _.applyTransition(slideIndex);
950
951 _.$slides.eq(slideIndex).css({
952 opacity: 1,
953 zIndex: _.options.zIndex
954 });
955
956 if (callback) {
957 setTimeout(function() {
958
959 _.disableTransition(slideIndex);
960
961 callback.call();
962 }, _.options.speed);
963 }
964
965 }
966
967 };
968
969 Slick.prototype.fadeSlideOut = function(slideIndex) {
970
971 var _ = this;
972
973 if (_.cssTransitions === false) {
974
975 _.$slides.eq(slideIndex).animate({
976 opacity: 0,
977 zIndex: _.options.zIndex - 2
978 }, _.options.speed, _.options.easing);
979
980 } else {
981
982 _.applyTransition(slideIndex);
983
984 _.$slides.eq(slideIndex).css({
985 opacity: 0,
986 zIndex: _.options.zIndex - 2
987 });
988
989 }
990
991 };
992
993 Slick.prototype.filterSlides = Slick.prototype.slickFilter = function(filter) {
994
995 var _ = this;
996
997 if (filter !== null) {
998
999 _.$slidesCache = _.$slides;
1000
1001 _.unload();
1002
1003 _.$slideTrack.children(this.options.slide).detach();
1004
1005 _.$slidesCache.filter(filter).appendTo(_.$slideTrack);
1006
1007 _.reinit();
1008
1009 }
1010
1011 };
1012
1013 Slick.prototype.focusHandler = function() {
1014
1015 var _ = this;
1016
1017 _.$slider
1018 .off('focus.slick blur.slick')
1019 .on('focus.slick blur.slick', '*', function(event) {
1020
1021 event.stopImmediatePropagation();
1022 var $sf = $(this);
1023
1024 setTimeout(function() {
1025
1026 if( _.options.pauseOnFocus ) {
1027 _.focussed = $sf.is(':focus');
1028 _.autoPlay();
1029 }
1030
1031 }, 0);
1032
1033 });
1034 };
1035
1036 Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide = function() {
1037
1038 var _ = this;
1039 return _.currentSlide;
1040
1041 };
1042
1043 Slick.prototype.getDotCount = function() {
1044
1045 var _ = this;
1046
1047 var breakPoint = 0;
1048 var counter = 0;
1049 var pagerQty = 0;
1050
1051 if (_.options.infinite === true) {
1052 if (_.slideCount <= _.options.slidesToShow) {
1053 ++pagerQty;
1054 } else {
1055 while (breakPoint < _.slideCount) {
1056 ++pagerQty;
1057 breakPoint = counter + _.options.slidesToScroll;
1058 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1059 }
1060 }
1061 } else if (_.options.centerMode === true) {
1062 pagerQty = _.slideCount;
1063 } else if(!_.options.asNavFor) {
1064 pagerQty = 1 + Math.ceil((_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll);
1065 }else {
1066 while (breakPoint < _.slideCount) {
1067 ++pagerQty;
1068 breakPoint = counter + _.options.slidesToScroll;
1069 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1070 }
1071 }
1072
1073 return pagerQty - 1;
1074
1075 };
1076
1077 Slick.prototype.getLeft = function(slideIndex) {
1078
1079 var _ = this,
1080 targetLeft,
1081 verticalHeight,
1082 verticalOffset = 0,
1083 targetSlide,
1084 coef;
1085
1086 _.slideOffset = 0;
1087 verticalHeight = _.$slides.first().outerHeight(true);
1088
1089 if (_.options.infinite === true) {
1090 if (_.slideCount > _.options.slidesToShow) {
1091 _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
1092 coef = -1
1093
1094 if (_.options.vertical === true && _.options.centerMode === true) {
1095 if (_.options.slidesToShow === 2) {
1096 coef = -1.5;
1097 } else if (_.options.slidesToShow === 1) {
1098 coef = -2
1099 }
1100 }
1101 verticalOffset = (verticalHeight * _.options.slidesToShow) * coef;
1102 }
1103 if (_.slideCount % _.options.slidesToScroll !== 0) {
1104 if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
1105 if (slideIndex > _.slideCount) {
1106 _.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;
1107 verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
1108 } else {
1109 _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
1110 verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
1111 }
1112 }
1113 }
1114 } else {
1115 if (slideIndex + _.options.slidesToShow > _.slideCount) {
1116 _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
1117 verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
1118 }
1119 }
1120
1121 if (_.slideCount <= _.options.slidesToShow) {
1122 _.slideOffset = 0;
1123 verticalOffset = 0;
1124 }
1125
1126 if (_.options.centerMode === true && _.slideCount <= _.options.slidesToShow) {
1127 _.slideOffset = ((_.slideWidth * Math.floor(_.options.slidesToShow)) / 2) - ((_.slideWidth * _.slideCount) / 2);
1128 } else if (_.options.centerMode === true && _.options.infinite === true) {
1129 _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
1130 } else if (_.options.centerMode === true) {
1131 _.slideOffset = 0;
1132 _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
1133 }
1134
1135 if (_.options.vertical === false) {
1136 targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
1137 } else {
1138 targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
1139 }
1140
1141 if (_.options.variableWidth === true) {
1142
1143 if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1144 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1145 } else {
1146 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
1147 }
1148
1149 if (_.options.rtl === true) {
1150 if (targetSlide[0]) {
1151 targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1152 } else {
1153 targetLeft = 0;
1154 }
1155 } else {
1156 targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1157 }
1158
1159 if (_.options.centerMode === true) {
1160 if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1161 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1162 } else {
1163 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
1164 }
1165
1166 if (_.options.rtl === true) {
1167 if (targetSlide[0]) {
1168 targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1169 } else {
1170 targetLeft = 0;
1171 }
1172 } else {
1173 targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1174 }
1175
1176 targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
1177 }
1178 }
1179
1180 return targetLeft;
1181
1182 };
1183
1184 Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {
1185
1186 var _ = this;
1187
1188 return _.options[option];
1189
1190 };
1191
1192 Slick.prototype.getNavigableIndexes = function() {
1193
1194 var _ = this,
1195 breakPoint = 0,
1196 counter = 0,
1197 indexes = [],
1198 max;
1199
1200 if (_.options.infinite === false) {
1201 max = _.slideCount;
1202 } else {
1203 breakPoint = _.options.slidesToScroll * -1;
1204 counter = _.options.slidesToScroll * -1;
1205 max = _.slideCount * 2;
1206 }
1207
1208 while (breakPoint < max) {
1209 indexes.push(breakPoint);
1210 breakPoint = counter + _.options.slidesToScroll;
1211 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1212 }
1213
1214 return indexes;
1215
1216 };
1217
1218 Slick.prototype.getSlick = function() {
1219
1220 return this;
1221
1222 };
1223
1224 Slick.prototype.getSlideCount = function() {
1225
1226 var _ = this,
1227 slidesTraversed, swipedSlide, centerOffset;
1228
1229 centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;
1230
1231 if (_.options.swipeToSlide === true) {
1232 _.$slideTrack.find('.slick-slide').each(function(index, slide) {
1233 if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
1234 swipedSlide = slide;
1235 return false;
1236 }
1237 });
1238
1239 slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;
1240
1241 return slidesTraversed;
1242
1243 } else {
1244 return _.options.slidesToScroll;
1245 }
1246
1247 };
1248
1249 Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {
1250
1251 var _ = this;
1252
1253 _.changeSlide({
1254 data: {
1255 message: 'index',
1256 index: parseInt(slide)
1257 }
1258 }, dontAnimate);
1259
1260 };
1261
1262 Slick.prototype.init = function(creation) {
1263
1264 var _ = this;
1265
1266 if (!$(_.$slider).hasClass('slick-initialized')) {
1267
1268 $(_.$slider).addClass('slick-initialized');
1269
1270 _.buildRows();
1271 _.buildOut();
1272 _.setProps();
1273 _.startLoad();
1274 _.loadSlider();
1275 _.initializeEvents();
1276 _.updateArrows();
1277 _.updateDots();
1278 _.checkResponsive(true);
1279 _.focusHandler();
1280
1281 }
1282
1283 if (creation) {
1284 _.$slider.trigger('init', [_]);
1285 }
1286
1287 if (_.options.accessibility === true) {
1288 _.initADA();
1289 }
1290
1291 if ( _.options.autoplay ) {
1292
1293 _.paused = false;
1294 _.autoPlay();
1295
1296 }
1297
1298 };
1299
1300 Slick.prototype.initADA = function() {
1301 var _ = this,
1302 numDotGroups = Math.ceil(_.slideCount / _.options.slidesToShow),
1303 tabControlIndexes = _.getNavigableIndexes().filter(function(val) {
1304 return (val >= 0) && (val < _.slideCount);
1305 });
1306
1307 _.$slides.add(_.$slideTrack.find('.slick-cloned')).attr({
1308 'aria-hidden': 'true',
1309 'tabindex': '-1'
1310 }).find('a, input, button, select').attr({
1311 'tabindex': '-1'
1312 });
1313
1314 if (_.$dots !== null) {
1315 _.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function(i) {
1316 var slideControlIndex = tabControlIndexes.indexOf(i);
1317
1318 $(this).attr({
1319 'role': 'tabpanel',
1320 'id': 'slick-slide' + _.instanceUid + i,
1321 'tabindex': -1
1322 });
1323
1324 if (slideControlIndex !== -1) {
1325 $(this).attr({
1326 'aria-describedby': 'slick-slide-control' + _.instanceUid + slideControlIndex
1327 });
1328 }
1329 });
1330
1331 _.$dots.attr('role', 'tablist').find('li').each(function(i) {
1332 var mappedSlideIndex = tabControlIndexes[i];
1333
1334 $(this).attr({
1335 'role': 'presentation'
1336 });
1337
1338 $(this).find('button').first().attr({
1339 'role': 'tab',
1340 'id': 'slick-slide-control' + _.instanceUid + i,
1341 'aria-controls': 'slick-slide' + _.instanceUid + mappedSlideIndex,
1342 'aria-label': (i + 1) + ' of ' + numDotGroups,
1343 'aria-selected': null,
1344 'tabindex': '-1'
1345 });
1346
1347 }).eq(_.currentSlide).find('button').attr({
1348 'aria-selected': 'true',
1349 'tabindex': '0'
1350 }).end();
1351 }
1352
1353 for (var i=_.currentSlide, max=i+_.options.slidesToShow; i < max; i++) {
1354 _.$slides.eq(i).attr('tabindex', 0);
1355 }
1356
1357 _.activateADA();
1358
1359 };
1360
1361 Slick.prototype.initArrowEvents = function() {
1362
1363 var _ = this;
1364
1365 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1366 _.$prevArrow
1367 .off('click.slick')
1368 .on('click.slick', {
1369 message: 'previous'
1370 }, _.changeSlide);
1371 _.$nextArrow
1372 .off('click.slick')
1373 .on('click.slick', {
1374 message: 'next'
1375 }, _.changeSlide);
1376
1377 if (_.options.accessibility === true) {
1378 _.$prevArrow.on('keydown.slick', _.keyHandler);
1379 _.$nextArrow.on('keydown.slick', _.keyHandler);
1380 }
1381 }
1382
1383 };
1384
1385 Slick.prototype.initDotEvents = function() {
1386
1387 var _ = this;
1388
1389 if (_.options.dots === true) {
1390 $('li', _.$dots).on('click.slick', {
1391 message: 'index'
1392 }, _.changeSlide);
1393
1394 if (_.options.accessibility === true) {
1395 _.$dots.on('keydown.slick', _.keyHandler);
1396 }
1397 }
1398
1399 if ( _.options.dots === true && _.options.pauseOnDotsHover === true ) {
1400
1401 $('li', _.$dots)
1402 .on('mouseenter.slick', $.proxy(_.interrupt, _, true))
1403 .on('mouseleave.slick', $.proxy(_.interrupt, _, false));
1404
1405 }
1406
1407 };
1408
1409 Slick.prototype.initSlideEvents = function() {
1410
1411 var _ = this;
1412
1413 if ( _.options.pauseOnHover ) {
1414
1415 _.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true));
1416 _.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false));
1417
1418 }
1419
1420 };
1421
1422 Slick.prototype.initializeEvents = function() {
1423
1424 var _ = this;
1425
1426 _.initArrowEvents();
1427
1428 _.initDotEvents();
1429 _.initSlideEvents();
1430
1431 _.$list.on('touchstart.slick mousedown.slick', {
1432 action: 'start'
1433 }, _.swipeHandler);
1434 _.$list.on('touchmove.slick mousemove.slick', {
1435 action: 'move'
1436 }, _.swipeHandler);
1437 _.$list.on('touchend.slick mouseup.slick', {
1438 action: 'end'
1439 }, _.swipeHandler);
1440 _.$list.on('touchcancel.slick mouseleave.slick', {
1441 action: 'end'
1442 }, _.swipeHandler);
1443
1444 _.$list.on('click.slick', _.clickHandler);
1445
1446 $(document).on(_.visibilityChange, $.proxy(_.visibility, _));
1447
1448 if (_.options.accessibility === true) {
1449 _.$list.on('keydown.slick', _.keyHandler);
1450 }
1451
1452 if (_.options.focusOnSelect === true) {
1453 $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1454 }
1455
1456 $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));
1457
1458 $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));
1459
1460 $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);
1461
1462 $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
1463 $(_.setPosition);
1464
1465 };
1466
1467 Slick.prototype.initUI = function() {
1468
1469 var _ = this;
1470
1471 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1472
1473 _.$prevArrow.show();
1474 _.$nextArrow.show();
1475
1476 }
1477
1478 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1479
1480 _.$dots.show();
1481
1482 }
1483
1484 };
1485
1486 Slick.prototype.keyHandler = function(event) {
1487
1488 var _ = this;
1489 //Dont slide if the cursor is inside the form fields and arrow keys are pressed
1490 if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
1491 if (event.keyCode === 37 && _.options.accessibility === true) {
1492 _.changeSlide({
1493 data: {
1494 message: _.options.rtl === true ? 'next' : 'previous'
1495 }
1496 });
1497 } else if (event.keyCode === 39 && _.options.accessibility === true) {
1498 _.changeSlide({
1499 data: {
1500 message: _.options.rtl === true ? 'previous' : 'next'
1501 }
1502 });
1503 }
1504 }
1505
1506 };
1507
1508 Slick.prototype.lazyLoad = function() {
1509
1510 var _ = this,
1511 loadRange, cloneRange, rangeStart, rangeEnd;
1512
1513 function loadImages(imagesScope) {
1514
1515 $('img[data-lazy]', imagesScope).each(function() {
1516
1517 var image = $(this),
1518 imageSource = $(this).attr('data-lazy'),
1519 imageSrcSet = $(this).attr('data-srcset'),
1520 imageSizes = $(this).attr('data-sizes') || _.$slider.attr('data-sizes'),
1521 imageToLoad = document.createElement('img');
1522
1523 imageToLoad.onload = function() {
1524
1525 image
1526 .animate({ opacity: 0 }, 100, function() {
1527
1528 if (imageSrcSet) {
1529 image
1530 .attr('srcset', imageSrcSet );
1531
1532 if (imageSizes) {
1533 image
1534 .attr('sizes', imageSizes );
1535 }
1536 }
1537
1538 image
1539 .attr('src', imageSource)
1540 .animate({ opacity: 1 }, 200, function() {
1541 image
1542 .removeAttr('data-lazy data-srcset data-sizes')
1543 .removeClass('slick-loading');
1544 });
1545 _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
1546 });
1547
1548 };
1549
1550 imageToLoad.onerror = function() {
1551
1552 image
1553 .removeAttr( 'data-lazy' )
1554 .removeClass( 'slick-loading' )
1555 .addClass( 'slick-lazyload-error' );
1556
1557 _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1558
1559 };
1560
1561 imageToLoad.src = imageSource;
1562
1563 });
1564
1565 }
1566
1567 if (_.options.centerMode === true) {
1568 if (_.options.infinite === true) {
1569 rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
1570 rangeEnd = rangeStart + _.options.slidesToShow + 2;
1571 } else {
1572 rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
1573 rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
1574 }
1575 } else {
1576 rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
1577 rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
1578 if (_.options.fade === true) {
1579 if (rangeStart > 0) rangeStart--;
1580 if (rangeEnd <= _.slideCount) rangeEnd++;
1581 }
1582 }
1583
1584 loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
1585
1586 if (_.options.lazyLoad === 'anticipated') {
1587 var prevSlide = rangeStart - 1,
1588 nextSlide = rangeEnd,
1589 $slides = _.$slider.find('.slick-slide');
1590
1591 for (var i = 0; i < _.options.slidesToScroll; i++) {
1592 if (prevSlide < 0) prevSlide = _.slideCount - 1;
1593 loadRange = loadRange.add($slides.eq(prevSlide));
1594 loadRange = loadRange.add($slides.eq(nextSlide));
1595 prevSlide--;
1596 nextSlide++;
1597 }
1598 }
1599
1600 loadImages(loadRange);
1601
1602 if (_.slideCount <= _.options.slidesToShow) {
1603 cloneRange = _.$slider.find('.slick-slide');
1604 loadImages(cloneRange);
1605 } else
1606 if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1607 cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
1608 loadImages(cloneRange);
1609 } else if (_.currentSlide === 0) {
1610 cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
1611 loadImages(cloneRange);
1612 }
1613
1614 };
1615
1616 Slick.prototype.loadSlider = function() {
1617
1618 var _ = this;
1619
1620 _.setPosition();
1621
1622 _.$slideTrack.css({
1623 opacity: 1
1624 });
1625
1626 _.$slider.removeClass('slick-loading');
1627
1628 _.initUI();
1629
1630 if (_.options.lazyLoad === 'progressive') {
1631 _.progressiveLazyLoad();
1632 }
1633
1634 };
1635
1636 Slick.prototype.next = Slick.prototype.slickNext = function() {
1637
1638 var _ = this;
1639
1640 _.changeSlide({
1641 data: {
1642 message: 'next'
1643 }
1644 });
1645
1646 };
1647
1648 Slick.prototype.orientationChange = function() {
1649
1650 var _ = this;
1651
1652 _.checkResponsive();
1653 _.setPosition();
1654
1655 };
1656
1657 Slick.prototype.pause = Slick.prototype.slickPause = function() {
1658
1659 var _ = this;
1660
1661 _.autoPlayClear();
1662 _.paused = true;
1663
1664 };
1665
1666 Slick.prototype.play = Slick.prototype.slickPlay = function() {
1667
1668 var _ = this;
1669
1670 _.autoPlay();
1671 _.options.autoplay = true;
1672 _.paused = false;
1673 _.focussed = false;
1674 _.interrupted = false;
1675
1676 };
1677
1678 Slick.prototype.postSlide = function(index) {
1679
1680 var _ = this;
1681
1682 if( !_.unslicked ) {
1683
1684 _.$slider.trigger('afterChange', [_, index]);
1685
1686 _.animating = false;
1687
1688 if (_.slideCount > _.options.slidesToShow) {
1689 _.setPosition();
1690 }
1691
1692 _.swipeLeft = null;
1693
1694 if ( _.options.autoplay ) {
1695 _.autoPlay();
1696 }
1697
1698 if (_.options.accessibility === true) {
1699 _.initADA();
1700
1701 if (_.options.focusOnChange) {
1702 var $currentSlide = $(_.$slides.get(_.currentSlide));
1703 $currentSlide.attr('tabindex', 0).focus();
1704 }
1705 }
1706
1707 }
1708
1709 };
1710
1711 Slick.prototype.prev = Slick.prototype.slickPrev = function() {
1712
1713 var _ = this;
1714
1715 _.changeSlide({
1716 data: {
1717 message: 'previous'
1718 }
1719 });
1720
1721 };
1722
1723 Slick.prototype.preventDefault = function(event) {
1724
1725 event.preventDefault();
1726
1727 };
1728
1729 Slick.prototype.progressiveLazyLoad = function( tryCount ) {
1730
1731 tryCount = tryCount || 1;
1732
1733 var _ = this,
1734 $imgsToLoad = $( 'img[data-lazy]', _.$slider ),
1735 image,
1736 imageSource,
1737 imageSrcSet,
1738 imageSizes,
1739 imageToLoad;
1740
1741 if ( $imgsToLoad.length ) {
1742
1743 image = $imgsToLoad.first();
1744 imageSource = image.attr('data-lazy');
1745 imageSrcSet = image.attr('data-srcset');
1746 imageSizes = image.attr('data-sizes') || _.$slider.attr('data-sizes');
1747 imageToLoad = document.createElement('img');
1748
1749 imageToLoad.onload = function() {
1750
1751 if (imageSrcSet) {
1752 image
1753 .attr('srcset', imageSrcSet );
1754
1755 if (imageSizes) {
1756 image
1757 .attr('sizes', imageSizes );
1758 }
1759 }
1760
1761 image
1762 .attr( 'src', imageSource )
1763 .removeAttr('data-lazy data-srcset data-sizes')
1764 .removeClass('slick-loading');
1765
1766 if ( _.options.adaptiveHeight === true ) {
1767 _.setPosition();
1768 }
1769
1770 _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);
1771 _.progressiveLazyLoad();
1772
1773 };
1774
1775 imageToLoad.onerror = function() {
1776
1777 if ( tryCount < 3 ) {
1778
1779 /**
1780 * try to load the image 3 times,
1781 * leave a slight delay so we don't get
1782 * servers blocking the request.
1783 */
1784 setTimeout( function() {
1785 _.progressiveLazyLoad( tryCount + 1 );
1786 }, 500 );
1787
1788 } else {
1789
1790 image
1791 .removeAttr( 'data-lazy' )
1792 .removeClass( 'slick-loading' )
1793 .addClass( 'slick-lazyload-error' );
1794
1795 _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1796
1797 _.progressiveLazyLoad();
1798
1799 }
1800
1801 };
1802
1803 imageToLoad.src = imageSource;
1804
1805 } else {
1806
1807 _.$slider.trigger('allImagesLoaded', [ _ ]);
1808
1809 }
1810
1811 };
1812
1813 Slick.prototype.refresh = function( initializing ) {
1814
1815 var _ = this, currentSlide, lastVisibleIndex;
1816
1817 lastVisibleIndex = _.slideCount - _.options.slidesToShow;
1818
1819 // in non-infinite sliders, we don't want to go past the
1820 // last visible index.
1821 if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {
1822 _.currentSlide = lastVisibleIndex;
1823 }
1824
1825 // if less slides than to show, go to start.
1826 if ( _.slideCount <= _.options.slidesToShow ) {
1827 _.currentSlide = 0;
1828
1829 }
1830
1831 currentSlide = _.currentSlide;
1832
1833 _.destroy(true);
1834
1835 $.extend(_, _.initials, { currentSlide: currentSlide });
1836
1837 _.init();
1838
1839 if( !initializing ) {
1840
1841 _.changeSlide({
1842 data: {
1843 message: 'index',
1844 index: currentSlide
1845 }
1846 }, false);
1847
1848 }
1849
1850 };
1851
1852 Slick.prototype.registerBreakpoints = function() {
1853
1854 var _ = this, breakpoint, currentBreakpoint, l,
1855 responsiveSettings = _.options.responsive || null;
1856
1857 if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {
1858
1859 _.respondTo = _.options.respondTo || 'window';
1860
1861 for ( breakpoint in responsiveSettings ) {
1862
1863 l = _.breakpoints.length-1;
1864
1865 if (responsiveSettings.hasOwnProperty(breakpoint)) {
1866 currentBreakpoint = responsiveSettings[breakpoint].breakpoint;
1867
1868 // loop through the breakpoints and cut out any existing
1869 // ones with the same breakpoint number, we don't want dupes.
1870 while( l >= 0 ) {
1871 if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {
1872 _.breakpoints.splice(l,1);
1873 }
1874 l--;
1875 }
1876
1877 _.breakpoints.push(currentBreakpoint);
1878 _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;
1879
1880 }
1881
1882 }
1883
1884 _.breakpoints.sort(function(a, b) {
1885 return ( _.options.mobileFirst ) ? a-b : b-a;
1886 });
1887
1888 }
1889
1890 };
1891
1892 Slick.prototype.reinit = function() {
1893
1894 var _ = this;
1895
1896 _.$slides =
1897 _.$slideTrack
1898 .children(_.options.slide)
1899 .addClass('slick-slide');
1900
1901 _.slideCount = _.$slides.length;
1902
1903 if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
1904 _.currentSlide = _.currentSlide - _.options.slidesToScroll;
1905 }
1906
1907 if (_.slideCount <= _.options.slidesToShow) {
1908 _.currentSlide = 0;
1909 }
1910
1911 _.registerBreakpoints();
1912
1913 _.setProps();
1914 _.setupInfinite();
1915 _.buildArrows();
1916 _.updateArrows();
1917 _.initArrowEvents();
1918 _.buildDots();
1919 _.updateDots();
1920 _.initDotEvents();
1921 _.cleanUpSlideEvents();
1922 _.initSlideEvents();
1923
1924 _.checkResponsive(false, true);
1925
1926 if (_.options.focusOnSelect === true) {
1927 $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1928 }
1929
1930 _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
1931
1932 _.setPosition();
1933 _.focusHandler();
1934
1935 _.paused = !_.options.autoplay;
1936 _.autoPlay();
1937
1938 _.$slider.trigger('reInit', [_]);
1939
1940 };
1941
1942 Slick.prototype.resize = function() {
1943
1944 var _ = this;
1945
1946 if ($(window).width() !== _.windowWidth) {
1947 clearTimeout(_.windowDelay);
1948 _.windowDelay = window.setTimeout(function() {
1949 _.windowWidth = $(window).width();
1950 _.checkResponsive();
1951 if( !_.unslicked ) { _.setPosition(); }
1952 }, 50);
1953 }
1954 };
1955
1956 Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {
1957
1958 var _ = this;
1959
1960 if (typeof(index) === 'boolean') {
1961 removeBefore = index;
1962 index = removeBefore === true ? 0 : _.slideCount - 1;
1963 } else {
1964 index = removeBefore === true ? --index : index;
1965 }
1966
1967 if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
1968 return false;
1969 }
1970
1971 _.unload();
1972
1973 if (removeAll === true) {
1974 _.$slideTrack.children().remove();
1975 } else {
1976 _.$slideTrack.children(this.options.slide).eq(index).remove();
1977 }
1978
1979 _.$slides = _.$slideTrack.children(this.options.slide);
1980
1981 _.$slideTrack.children(this.options.slide).detach();
1982
1983 _.$slideTrack.append(_.$slides);
1984
1985 _.$slidesCache = _.$slides;
1986
1987 _.reinit();
1988
1989 };
1990
1991 Slick.prototype.setCSS = function(position) {
1992
1993 var _ = this,
1994 positionProps = {},
1995 x, y;
1996
1997 if (_.options.rtl === true) {
1998 position = -position;
1999 }
2000 x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
2001 y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
2002
2003 positionProps[_.positionProp] = position;
2004
2005 if (_.transformsEnabled === false) {
2006 _.$slideTrack.css(positionProps);
2007 } else {
2008 positionProps = {};
2009 if (_.cssTransitions === false) {
2010 positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
2011 _.$slideTrack.css(positionProps);
2012 } else {
2013 positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
2014 _.$slideTrack.css(positionProps);
2015 }
2016 }
2017
2018 };
2019
2020 Slick.prototype.setDimensions = function() {
2021
2022 var _ = this;
2023
2024 if (_.options.vertical === false) {
2025 if (_.options.centerMode === true) {
2026 _.$list.css({
2027 padding: ('0px ' + _.options.centerPadding)
2028 });
2029 }
2030 } else {
2031 _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
2032 if (_.options.centerMode === true) {
2033 _.$list.css({
2034 padding: (_.options.centerPadding + ' 0px')
2035 });
2036 }
2037 }
2038
2039 _.listWidth = _.$list.width();
2040 _.listHeight = _.$list.height();
2041
2042
2043 if (_.options.vertical === false && _.options.variableWidth === false) {
2044 _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
2045 _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
2046
2047 } else if (_.options.variableWidth === true) {
2048 _.$slideTrack.width(5000 * _.slideCount);
2049 } else {
2050 _.slideWidth = Math.ceil(_.listWidth);
2051 _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
2052 }
2053
2054 var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
2055 if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
2056
2057 };
2058
2059 Slick.prototype.setFade = function() {
2060
2061 var _ = this,
2062 targetLeft;
2063
2064 _.$slides.each(function(index, element) {
2065 targetLeft = (_.slideWidth * index) * -1;
2066 if (_.options.rtl === true) {
2067 $(element).css({
2068 position: 'relative',
2069 right: targetLeft,
2070 top: 0,
2071 zIndex: _.options.zIndex - 2,
2072 opacity: 0
2073 });
2074 } else {
2075 $(element).css({
2076 position: 'relative',
2077 left: targetLeft,
2078 top: 0,
2079 zIndex: _.options.zIndex - 2,
2080 opacity: 0
2081 });
2082 }
2083 });
2084
2085 _.$slides.eq(_.currentSlide).css({
2086 zIndex: _.options.zIndex - 1,
2087 opacity: 1
2088 });
2089
2090 };
2091
2092 Slick.prototype.setHeight = function() {
2093
2094 var _ = this;
2095
2096 if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
2097 var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
2098 _.$list.css('height', targetHeight);
2099 }
2100
2101 };
2102
2103 Slick.prototype.setOption =
2104 Slick.prototype.slickSetOption = function() {
2105
2106 /**
2107 * accepts arguments in format of:
2108 *
2109 * - for changing a single option's value:
2110 * .slick("setOption", option, value, refresh )
2111 *
2112 * - for changing a set of responsive options:
2113 * .slick("setOption", 'responsive', [{}, ...], refresh )
2114 *
2115 * - for updating multiple values at once (not responsive)
2116 * .slick("setOption", { 'option': value, ... }, refresh )
2117 */
2118
2119 var _ = this, l, item, option, value, refresh = false, type;
2120
2121 if( $.type( arguments[0] ) === 'object' ) {
2122
2123 option = arguments[0];
2124 refresh = arguments[1];
2125 type = 'multiple';
2126
2127 } else if ( $.type( arguments[0] ) === 'string' ) {
2128
2129 option = arguments[0];
2130 value = arguments[1];
2131 refresh = arguments[2];
2132
2133 if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {
2134
2135 type = 'responsive';
2136
2137 } else if ( typeof arguments[1] !== 'undefined' ) {
2138
2139 type = 'single';
2140
2141 }
2142
2143 }
2144
2145 if ( type === 'single' ) {
2146
2147 _.options[option] = value;
2148
2149
2150 } else if ( type === 'multiple' ) {
2151
2152 $.each( option , function( opt, val ) {
2153
2154 _.options[opt] = val;
2155
2156 });
2157
2158
2159 } else if ( type === 'responsive' ) {
2160
2161 for ( item in value ) {
2162
2163 if( $.type( _.options.responsive ) !== 'array' ) {
2164
2165 _.options.responsive = [ value[item] ];
2166
2167 } else {
2168
2169 l = _.options.responsive.length-1;
2170
2171 // loop through the responsive object and splice out duplicates.
2172 while( l >= 0 ) {
2173
2174 if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {
2175
2176 _.options.responsive.splice(l,1);
2177
2178 }
2179
2180 l--;
2181
2182 }
2183
2184 _.options.responsive.push( value[item] );
2185
2186 }
2187
2188 }
2189
2190 }
2191
2192 if ( refresh ) {
2193
2194 _.unload();
2195 _.reinit();
2196
2197 }
2198
2199 };
2200
2201 Slick.prototype.setPosition = function() {
2202
2203 var _ = this;
2204
2205 _.setDimensions();
2206
2207 _.setHeight();
2208
2209 if (_.options.fade === false) {
2210 _.setCSS(_.getLeft(_.currentSlide));
2211 } else {
2212 _.setFade();
2213 }
2214
2215 _.$slider.trigger('setPosition', [_]);
2216
2217 };
2218
2219 Slick.prototype.setProps = function() {
2220
2221 var _ = this,
2222 bodyStyle = document.body.style;
2223
2224 _.positionProp = _.options.vertical === true ? 'top' : 'left';
2225
2226 if (_.positionProp === 'top') {
2227 _.$slider.addClass('slick-vertical');
2228 } else {
2229 _.$slider.removeClass('slick-vertical');
2230 }
2231
2232 if (bodyStyle.WebkitTransition !== undefined ||
2233 bodyStyle.MozTransition !== undefined ||
2234 bodyStyle.msTransition !== undefined) {
2235 if (_.options.useCSS === true) {
2236 _.cssTransitions = true;
2237 }
2238 }
2239
2240 if ( _.options.fade ) {
2241 if ( typeof _.options.zIndex === 'number' ) {
2242 if( _.options.zIndex < 3 ) {
2243 _.options.zIndex = 3;
2244 }
2245 } else {
2246 _.options.zIndex = _.defaults.zIndex;
2247 }
2248 }
2249
2250 if (bodyStyle.OTransform !== undefined) {
2251 _.animType = 'OTransform';
2252 _.transformType = '-o-transform';
2253 _.transitionType = 'OTransition';
2254 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2255 }
2256 if (bodyStyle.MozTransform !== undefined) {
2257 _.animType = 'MozTransform';
2258 _.transformType = '-moz-transform';
2259 _.transitionType = 'MozTransition';
2260 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
2261 }
2262 if (bodyStyle.webkitTransform !== undefined) {
2263 _.animType = 'webkitTransform';
2264 _.transformType = '-webkit-transform';
2265 _.transitionType = 'webkitTransition';
2266 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2267 }
2268 if (bodyStyle.msTransform !== undefined) {
2269 _.animType = 'msTransform';
2270 _.transformType = '-ms-transform';
2271 _.transitionType = 'msTransition';
2272 if (bodyStyle.msTransform === undefined) _.animType = false;
2273 }
2274 if (bodyStyle.transform !== undefined && _.animType !== false) {
2275 _.animType = 'transform';
2276 _.transformType = 'transform';
2277 _.transitionType = 'transition';
2278 }
2279 _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);
2280 };
2281
2282
2283 Slick.prototype.setSlideClasses = function(index) {
2284
2285 var _ = this,
2286 centerOffset, allSlides, indexOffset, remainder;
2287
2288 allSlides = _.$slider
2289 .find('.slick-slide')
2290 .removeClass('slick-active slick-center slick-current')
2291 .attr('aria-hidden', 'true');
2292
2293 _.$slides
2294 .eq(index)
2295 .addClass('slick-current');
2296
2297 if (_.options.centerMode === true) {
2298
2299 var evenCoef = _.options.slidesToShow % 2 === 0 ? 1 : 0;
2300
2301 centerOffset = Math.floor(_.options.slidesToShow / 2);
2302
2303 if (_.options.infinite === true) {
2304
2305 if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
2306 _.$slides
2307 .slice(index - centerOffset + evenCoef, index + centerOffset + 1)
2308 .addClass('slick-active')
2309 .attr('aria-hidden', 'false');
2310
2311 } else {
2312
2313 indexOffset = _.options.slidesToShow + index;
2314 allSlides
2315 .slice(indexOffset - centerOffset + 1 + evenCoef, indexOffset + centerOffset + 2)
2316 .addClass('slick-active')
2317 .attr('aria-hidden', 'false');
2318
2319 }
2320
2321 if (index === 0) {
2322
2323 allSlides
2324 .eq(allSlides.length - 1 - _.options.slidesToShow)
2325 .addClass('slick-center');
2326
2327 } else if (index === _.slideCount - 1) {
2328
2329 allSlides
2330 .eq(_.options.slidesToShow)
2331 .addClass('slick-center');
2332
2333 }
2334
2335 }
2336
2337 _.$slides
2338 .eq(index)
2339 .addClass('slick-center');
2340
2341 } else {
2342
2343 if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {
2344
2345 _.$slides
2346 .slice(index, index + _.options.slidesToShow)
2347 .addClass('slick-active')
2348 .attr('aria-hidden', 'false');
2349
2350 } else if (allSlides.length <= _.options.slidesToShow) {
2351
2352 allSlides
2353 .addClass('slick-active')
2354 .attr('aria-hidden', 'false');
2355
2356 } else {
2357
2358 remainder = _.slideCount % _.options.slidesToShow;
2359 indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
2360
2361 if (_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {
2362
2363 allSlides
2364 .slice(indexOffset - (_.options.slidesToShow - remainder), indexOffset + remainder)
2365 .addClass('slick-active')
2366 .attr('aria-hidden', 'false');
2367
2368 } else {
2369
2370 allSlides
2371 .slice(indexOffset, indexOffset + _.options.slidesToShow)
2372 .addClass('slick-active')
2373 .attr('aria-hidden', 'false');
2374
2375 }
2376
2377 }
2378
2379 }
2380
2381 if (_.options.lazyLoad === 'ondemand' || _.options.lazyLoad === 'anticipated') {
2382 _.lazyLoad();
2383 }
2384 };
2385
2386 Slick.prototype.setupInfinite = function() {
2387
2388 var _ = this,
2389 i, slideIndex, infiniteCount;
2390
2391 if (_.options.fade === true) {
2392 _.options.centerMode = false;
2393 }
2394
2395 if (_.options.infinite === true && _.options.fade === false) {
2396
2397 slideIndex = null;
2398
2399 if (_.slideCount > _.options.slidesToShow) {
2400
2401 if (_.options.centerMode === true) {
2402 infiniteCount = _.options.slidesToShow + 1;
2403 } else {
2404 infiniteCount = _.options.slidesToShow;
2405 }
2406
2407 for (i = _.slideCount; i > (_.slideCount -
2408 infiniteCount); i -= 1) {
2409 slideIndex = i - 1;
2410 $(_.$slides[slideIndex]).clone(true).attr('id', '')
2411 .attr('data-slick-index', slideIndex - _.slideCount)
2412 .prependTo(_.$slideTrack).addClass('slick-cloned');
2413 }
2414 for (i = 0; i < infiniteCount + _.slideCount; i += 1) {
2415 slideIndex = i;
2416 $(_.$slides[slideIndex]).clone(true).attr('id', '')
2417 .attr('data-slick-index', slideIndex + _.slideCount)
2418 .appendTo(_.$slideTrack).addClass('slick-cloned');
2419 }
2420 _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
2421 $(this).attr('id', '');
2422 });
2423
2424 }
2425
2426 }
2427
2428 };
2429
2430 Slick.prototype.interrupt = function( toggle ) {
2431
2432 var _ = this;
2433
2434 if( !toggle ) {
2435 _.autoPlay();
2436 }
2437 _.interrupted = toggle;
2438
2439 };
2440
2441 Slick.prototype.selectHandler = function(event) {
2442
2443 var _ = this;
2444
2445 var targetElement =
2446 $(event.target).is('.slick-slide') ?
2447 $(event.target) :
2448 $(event.target).parents('.slick-slide');
2449
2450 var index = parseInt(targetElement.attr('data-slick-index'));
2451
2452 if (!index) index = 0;
2453
2454 if (_.slideCount <= _.options.slidesToShow) {
2455
2456 _.slideHandler(index, false, true);
2457 return;
2458
2459 }
2460
2461 _.slideHandler(index);
2462
2463 };
2464
2465 Slick.prototype.slideHandler = function(index, sync, dontAnimate) {
2466
2467 var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,
2468 _ = this, navTarget;
2469
2470 sync = sync || false;
2471
2472 if (_.animating === true && _.options.waitForAnimate === true) {
2473 return;
2474 }
2475
2476 if (_.options.fade === true && _.currentSlide === index) {
2477 return;
2478 }
2479
2480 if (sync === false) {
2481 _.asNavFor(index);
2482 }
2483
2484 targetSlide = index;
2485 targetLeft = _.getLeft(targetSlide);
2486 slideLeft = _.getLeft(_.currentSlide);
2487
2488 _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
2489
2490 if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
2491 if (_.options.fade === false) {
2492 targetSlide = _.currentSlide;
2493 if (dontAnimate !== true) {
2494 _.animateSlide(slideLeft, function() {
2495 _.postSlide(targetSlide);
2496 });
2497 } else {
2498 _.postSlide(targetSlide);
2499 }
2500 }
2501 return;
2502 } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
2503 if (_.options.fade === false) {
2504 targetSlide = _.currentSlide;
2505 if (dontAnimate !== true) {
2506 _.animateSlide(slideLeft, function() {
2507 _.postSlide(targetSlide);
2508 });
2509 } else {
2510 _.postSlide(targetSlide);
2511 }
2512 }
2513 return;
2514 }
2515
2516 if ( _.options.autoplay ) {
2517 clearInterval(_.autoPlayTimer);
2518 }
2519
2520 if (targetSlide < 0) {
2521 if (_.slideCount % _.options.slidesToScroll !== 0) {
2522 animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
2523 } else {
2524 animSlide = _.slideCount + targetSlide;
2525 }
2526 } else if (targetSlide >= _.slideCount) {
2527 if (_.slideCount % _.options.slidesToScroll !== 0) {
2528 animSlide = 0;
2529 } else {
2530 animSlide = targetSlide - _.slideCount;
2531 }
2532 } else {
2533 animSlide = targetSlide;
2534 }
2535
2536 _.animating = true;
2537
2538 _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);
2539
2540 oldSlide = _.currentSlide;
2541 _.currentSlide = animSlide;
2542
2543 _.setSlideClasses(_.currentSlide);
2544
2545 if ( _.options.asNavFor ) {
2546
2547 navTarget = _.getNavTarget();
2548 navTarget = navTarget.slick('getSlick');
2549
2550 if ( navTarget.slideCount <= navTarget.options.slidesToShow ) {
2551 navTarget.setSlideClasses(_.currentSlide);
2552 }
2553
2554 }
2555
2556 _.updateDots();
2557 _.updateArrows();
2558
2559 if (_.options.fade === true) {
2560 if (dontAnimate !== true) {
2561
2562 _.fadeSlideOut(oldSlide);
2563
2564 _.fadeSlide(animSlide, function() {
2565 _.postSlide(animSlide);
2566 });
2567
2568 } else {
2569 _.postSlide(animSlide);
2570 }
2571 _.animateHeight();
2572 return;
2573 }
2574
2575 if (dontAnimate !== true) {
2576 _.animateSlide(targetLeft, function() {
2577 _.postSlide(animSlide);
2578 });
2579 } else {
2580 _.postSlide(animSlide);
2581 }
2582
2583 };
2584
2585 Slick.prototype.startLoad = function() {
2586
2587 var _ = this;
2588
2589 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2590
2591 _.$prevArrow.hide();
2592 _.$nextArrow.hide();
2593
2594 }
2595
2596 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
2597
2598 _.$dots.hide();
2599
2600 }
2601
2602 _.$slider.addClass('slick-loading');
2603
2604 };
2605
2606 Slick.prototype.swipeDirection = function() {
2607
2608 var xDist, yDist, r, swipeAngle, _ = this;
2609
2610 xDist = _.touchObject.startX - _.touchObject.curX;
2611 yDist = _.touchObject.startY - _.touchObject.curY;
2612 r = Math.atan2(yDist, xDist);
2613
2614 swipeAngle = Math.round(r * 180 / Math.PI);
2615 if (swipeAngle < 0) {
2616 swipeAngle = 360 - Math.abs(swipeAngle);
2617 }
2618
2619 if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
2620 return (_.options.rtl === false ? 'left' : 'right');
2621 }
2622 if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
2623 return (_.options.rtl === false ? 'left' : 'right');
2624 }
2625 if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
2626 return (_.options.rtl === false ? 'right' : 'left');
2627 }
2628 if (_.options.verticalSwiping === true) {
2629 if ((swipeAngle >= 35) && (swipeAngle <= 135)) {
2630 return 'down';
2631 } else {
2632 return 'up';
2633 }
2634 }
2635
2636 return 'vertical';
2637
2638 };
2639
2640 Slick.prototype.swipeEnd = function(event) {
2641
2642 var _ = this,
2643 slideCount,
2644 direction;
2645
2646 _.dragging = false;
2647 _.swiping = false;
2648
2649 if (_.scrolling) {
2650 _.scrolling = false;
2651 return false;
2652 }
2653
2654 _.interrupted = false;
2655 _.shouldClick = ( _.touchObject.swipeLength > 10 ) ? false : true;
2656
2657 if ( _.touchObject.curX === undefined ) {
2658 return false;
2659 }
2660
2661 if ( _.touchObject.edgeHit === true ) {
2662 _.$slider.trigger('edge', [_, _.swipeDirection() ]);
2663 }
2664
2665 if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {
2666
2667 direction = _.swipeDirection();
2668
2669 switch ( direction ) {
2670
2671 case 'left':
2672 case 'down':
2673
2674 slideCount =
2675 _.options.swipeToSlide ?
2676 _.checkNavigable( _.currentSlide + _.getSlideCount() ) :
2677 _.currentSlide + _.getSlideCount();
2678
2679 _.currentDirection = 0;
2680
2681 break;
2682
2683 case 'right':
2684 case 'up':
2685
2686 slideCount =
2687 _.options.swipeToSlide ?
2688 _.checkNavigable( _.currentSlide - _.getSlideCount() ) :
2689 _.currentSlide - _.getSlideCount();
2690
2691 _.currentDirection = 1;
2692
2693 break;
2694
2695 default:
2696
2697
2698 }
2699
2700 if( direction != 'vertical' ) {
2701
2702 _.slideHandler( slideCount );
2703 _.touchObject = {};
2704 _.$slider.trigger('swipe', [_, direction ]);
2705
2706 }
2707
2708 } else {
2709
2710 if ( _.touchObject.startX !== _.touchObject.curX ) {
2711
2712 _.slideHandler( _.currentSlide );
2713 _.touchObject = {};
2714
2715 }
2716
2717 }
2718
2719 };
2720
2721 Slick.prototype.swipeHandler = function(event) {
2722
2723 var _ = this;
2724
2725 if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
2726 return;
2727 } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
2728 return;
2729 }
2730
2731 _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
2732 event.originalEvent.touches.length : 1;
2733
2734 _.touchObject.minSwipe = _.listWidth / _.options
2735 .touchThreshold;
2736
2737 if (_.options.verticalSwiping === true) {
2738 _.touchObject.minSwipe = _.listHeight / _.options
2739 .touchThreshold;
2740 }
2741
2742 switch (event.data.action) {
2743
2744 case 'start':
2745 _.swipeStart(event);
2746 break;
2747
2748 case 'move':
2749 _.swipeMove(event);
2750 break;
2751
2752 case 'end':
2753 _.swipeEnd(event);
2754 break;
2755
2756 }
2757
2758 };
2759
2760 Slick.prototype.swipeMove = function(event) {
2761
2762 var _ = this,
2763 edgeWasHit = false,
2764 curLeft, swipeDirection, swipeLength, positionOffset, touches, verticalSwipeLength;
2765
2766 touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
2767
2768 if (!_.dragging || _.scrolling || touches && touches.length !== 1) {
2769 return false;
2770 }
2771
2772 curLeft = _.getLeft(_.currentSlide);
2773
2774 _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
2775 _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
2776
2777 _.touchObject.swipeLength = Math.round(Math.sqrt(
2778 Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
2779
2780 verticalSwipeLength = Math.round(Math.sqrt(
2781 Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));
2782
2783 if (!_.options.verticalSwiping && !_.swiping && verticalSwipeLength > 4) {
2784 _.scrolling = true;
2785 return false;
2786 }
2787
2788 if (_.options.verticalSwiping === true) {
2789 _.touchObject.swipeLength = verticalSwipeLength;
2790 }
2791
2792 swipeDirection = _.swipeDirection();
2793
2794 if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
2795 _.swiping = true;
2796 event.preventDefault();
2797 }
2798
2799 positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);
2800 if (_.options.verticalSwiping === true) {
2801 positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;
2802 }
2803
2804
2805 swipeLength = _.touchObject.swipeLength;
2806
2807 _.touchObject.edgeHit = false;
2808
2809 if (_.options.infinite === false) {
2810 if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {
2811 swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;
2812 _.touchObject.edgeHit = true;
2813 }
2814 }
2815
2816 if (_.options.vertical === false) {
2817 _.swipeLeft = curLeft + swipeLength * positionOffset;
2818 } else {
2819 _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
2820 }
2821 if (_.options.verticalSwiping === true) {
2822 _.swipeLeft = curLeft + swipeLength * positionOffset;
2823 }
2824
2825 if (_.options.fade === true || _.options.touchMove === false) {
2826 return false;
2827 }
2828
2829 if (_.animating === true) {
2830 _.swipeLeft = null;
2831 return false;
2832 }
2833
2834 _.setCSS(_.swipeLeft);
2835
2836 };
2837
2838 Slick.prototype.swipeStart = function(event) {
2839
2840 var _ = this,
2841 touches;
2842
2843 _.interrupted = true;
2844
2845 if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
2846 _.touchObject = {};
2847 return false;
2848 }
2849
2850 if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
2851 touches = event.originalEvent.touches[0];
2852 }
2853
2854 _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
2855 _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
2856
2857 _.dragging = true;
2858
2859 };
2860
2861 Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {
2862
2863 var _ = this;
2864
2865 if (_.$slidesCache !== null) {
2866
2867 _.unload();
2868
2869 _.$slideTrack.children(this.options.slide).detach();
2870
2871 _.$slidesCache.appendTo(_.$slideTrack);
2872
2873 _.reinit();
2874
2875 }
2876
2877 };
2878
2879 Slick.prototype.unload = function() {
2880
2881 var _ = this;
2882
2883 $('.slick-cloned', _.$slider).remove();
2884
2885 if (_.$dots) {
2886 _.$dots.remove();
2887 }
2888
2889 if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {
2890 _.$prevArrow.remove();
2891 }
2892
2893 if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {
2894 _.$nextArrow.remove();
2895 }
2896
2897 _.$slides
2898 .removeClass('slick-slide slick-active slick-visible slick-current')
2899 .attr('aria-hidden', 'true')
2900 .css('width', '');
2901
2902 };
2903
2904 Slick.prototype.unslick = function(fromBreakpoint) {
2905
2906 var _ = this;
2907 _.$slider.trigger('unslick', [_, fromBreakpoint]);
2908 _.destroy();
2909
2910 };
2911
2912 Slick.prototype.updateArrows = function() {
2913
2914 var _ = this,
2915 centerOffset;
2916
2917 centerOffset = Math.floor(_.options.slidesToShow / 2);
2918
2919 if ( _.options.arrows === true &&
2920 _.slideCount > _.options.slidesToShow &&
2921 !_.options.infinite ) {
2922
2923 _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2924 _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2925
2926 if (_.currentSlide === 0) {
2927
2928 _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
2929 _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2930
2931 } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow && _.options.centerMode === false) {
2932
2933 _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
2934 _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2935
2936 } else if (_.currentSlide >= _.slideCount - 1 && _.options.centerMode === true) {
2937
2938 _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
2939 _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2940
2941 }
2942
2943 }
2944
2945 };
2946
2947 Slick.prototype.updateDots = function() {
2948
2949 var _ = this;
2950
2951 if (_.$dots !== null) {
2952
2953 _.$dots
2954 .find('li')
2955 .removeClass('slick-active')
2956 .end();
2957
2958 _.$dots
2959 .find('li')
2960 .eq(Math.floor(_.currentSlide / _.options.slidesToScroll))
2961 .addClass('slick-active');
2962
2963 }
2964
2965 };
2966
2967 Slick.prototype.visibility = function() {
2968
2969 var _ = this;
2970
2971 if ( _.options.autoplay ) {
2972
2973 if ( document[_.hidden] ) {
2974
2975 _.interrupted = true;
2976
2977 } else {
2978
2979 _.interrupted = false;
2980
2981 }
2982
2983 }
2984
2985 };
2986
2987 $.fn.slick = function() {
2988 var _ = this,
2989 opt = arguments[0],
2990 args = Array.prototype.slice.call(arguments, 1),
2991 l = _.length,
2992 i,
2993 ret;
2994 for (i = 0; i < l; i++) {
2995 if (typeof opt == 'object' || typeof opt == 'undefined')
2996 _[i].slick = new Slick(_[i], opt);
2997 else
2998 ret = _[i].slick[opt].apply(_[i].slick, args);
2999 if (typeof ret != 'undefined') return ret;
3000 }
3001 return _;
3002 };
3003
3004 }));
